const global_host = "https://www.snoob.store" // 全局域名，生成环境
// const global_host = "http://127.0.0.1:8080" // 全局域名，开发环境

// 格式化时间
const formatTime = date => {
  const year = date.getFullYear()
  const month = date.getMonth() + 1
  const day = date.getDate()
  const hour = date.getHours()
  const minute = date.getMinutes()
  const second = date.getSeconds()

  return [year, month, day].map(formatNumber).join('/') + ' ' + [hour, minute, second].map(formatNumber).join(':')
}

// 格式化数字
const formatNumber = n => {
  n = n.toString()
  return n[1] ? n : '0' + n
}

//用于生成uuid
function S4() {
  return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
}
const guid = () => {
  return (S4() + S4() + "-" + S4() + "-" + S4() + "-" + S4() + "-" + S4() + S4() + S4());
}

// 数组a减去数组b
const arraySubtracting = (a, b) => {
  const len = b.length;
  for (let i = 0; i < len; i++) {
    const index = a.indexOf(b[i]);
    if (index > -1) {
      a.splice(index, 1);
    }
  }
  return a;
}

/**
 *  获取临时登录凭证code
 *    1、发送code到服务器
 *    2、根据code、appid、secret获取openid、session_key并入库
 *    3、加密openid发送到移动端异步保存在本地缓存
 */
const login = () => {
  wx.login({
    success: loginRes => {
      if (loginRes.code) {
        wx.request({
          url: global_host + "/gdd/xcx/login",
          data: {
            code: loginRes.code
          },
          success: res => {
            if (res.data.code == 0) {
              wx.setStorageSync("openId", res.data.data)
            }
          }
        })
      }
    }
  })
}

/**
 * 判断某个scope授权状态
 * scope.userInfo       // 用户信息
 * scope.userLocation   // 地理位置
 * scope.address        // 通讯地址
 * scope.invoiceTitle   // 发票抬头
 * scope.werun          // 	微信运动步数
 * scope.record         // 	录音功能
 * scope.writePhotosAlbum    // 保存到相册
 * scope.camera         // 摄像头
 */
const isAuthorized = (scope) => {
  return new Promise((resolve, reject) => {
    wx.getSetting({ // 获取用户的当前设置。返回值中只会出现小程序已经向用户请求过的权限
      success: res => {
        let isAuthorized = res.authSetting[scope] // 是否授权过 scope，undefined初次授权、true已经授权、false拒绝授权
        switch (scope) {
          case "scope.userInfo":
            isAuthorized = isAuthorized == true ? true : false // userInfo只有在授权后才可以直接调用
            break
          default:
            isAuthorized = isAuthorized == false ? false : true
            break
        }
        resolve(isAuthorized)
      }
    })
  })
}

/**
 * 获取用户信息，用户授权成功之后才可以调用该接口，否则调用失败
 */
const getUserInfo = () => {
  return new Promise((resolve, reject) => {
    isAuthorized("scope.userInfo").then(res => {
      if (res) {
        // 可以调用该接口获取用户基本信息
        wx.getUserInfo({
          success: res => {
            resolve(res.userInfo)
          }
        })
      }
    })
  })
}

/**
 * 获取微信通讯地址信息
 */
const chooseAddress = (this_) => {
  return new Promise((resolve, reject) => {
    isAuthorized("scope.address").then(res => {
      if (res) {
        // 可以调用该接口获取通讯地址信息，首次调用会出现授权弹框
        wx.chooseAddress({
          success: res => {
            if (typeof res === 'object' && res.cityName != "南京市") {
              wx.showToast({
                title: "请选择南京市范围内的地址",
                icon: "none",
                duration: 2000,
                mask: true
              })
              // 地址非法
              resolve("illegal")
            }
            resolve(res)
          },
          fail: res => {
            // 用户拒绝获取通讯地址信息
            resolve("refuse")
          }
        })
      } else {
        // 由于用户之前拒绝了授权,所以需要引导用户再次授权才可以获取通讯地址信息
        this_.setData({
          authDialogClosed: false
        })
        resolve("refused")
      }
    })
  })
}

/**
Promise（承诺，承诺将来会执行）
  JavaScript是单线程执行的，所有网络操作、浏览器事件、都必须是异步执行
  现在有一种需求：有若干个异步任务，需要先做任务1，如果成功后再做任务2，任何任务失败则不再继续并执行错误处理函数
================================================Promise对象一旦定义就会立即执行，应该以函数的形式包裹并返回
================================================ p1、p2、p3是函数
p1: function() {
  return new Promise(function(resolve, reject) {
    console.log('p1 resolved')
    resolve("p1")
  })
},
p2: function() {
  return new Promise(function(resolve, reject) {
    console.log('p2 rejected')
    reject("p2")
  })
},
p3: function() {
  return new Promise(function(resolve, reject) {
    console.log('p3 resolved')
    resolve("p3")
  })
},
p1().then(p2).then(p3).catch(error => {console.log('error: ' + error)})
// p1 resolved
// p2 rejected
// error: p2
 */

/**
 * requestType 请求类型 GET|POST
 * url 请求链接
 * param 请求参数
 * configuration 配置参数
 *    isLogin
 *        true表示本次请求必须在登录状态下才可以进行
 *        false表示本次请求无需登录即可以进行
 *    isPrePage
 *        true表示本次请求出错需要跳转到上一页
 *        false表示本次请求出错无需跳转到上一页
 */
const http = function(requestType, url, param, configuration) {
  return new Promise((resovle, reject) => {
    const isLogin = configuration.isLogin
    const isPrePage = configuration.isPrePage
    let header = {
      "content-type": "application/json"
    }
    /**
     * 需要登陆
     */
    if (isLogin) {
      // header.Authorization = "Bearer" + jwt
      const openId = wx.getStorageSync("openId")
      if (openId) {
        param.openId = openId
      } else {
        login()
        requestHandle("服务器繁忙，请稍后重试", isPrePage)
        reject(false)
        return
      }
    }
    if (url.includes('select')) {
      wx.showLoading({
        title: '正在加载...',
        duration: 200,
        mask: true
      })
    }
    /**
     * 发送request请求
     */
    wx.request({
      url: global_host + url,
      data: param,
      header: header,
      method: requestType,
      dataType: "json",
      responseType: "text",
      success: requestRes => {
        if (requestRes.statusCode === 200) {
          if (requestRes.data.code == 0) {
            // 服务器响应成功，返回requestRes.data.data
            requestHandle(null, false)
            resovle(requestRes.data.data)
          } else if (requestRes.data.code == 1000) {
            // 服务器响应成功，登陆超时
            login()
            requestHandle("登陆超时", isPrePage)
            reject(requestRes.data.msg)
          } else {
            // 服务器响应成功，系统错误
            requestHandle(requestRes.data.msg, isPrePage)
            reject(requestRes.data.msg)
          }
        } else if (requestRes.statusCode === 502) {
          // 服务器响应502
          requestHandle("与服务器断开连接，请联系管理员", isPrePage)
          reject(false)
        } else {
          requestHandle("服务器状态码: " + requestRes.statusCode, isPrePage)
          reject(false)
        }
      },
      fail: requestRes => {
        requestHandle("网络请求失败，稍后重试", isPrePage)
        reject(requestRes)
      },
      complete: () => {
        if (url.includes('page') || url.includes('select')) {
          setTimeout(() => {
            // 关闭下拉刷新
            wx.stopPullDownRefresh()
            // 关闭加载提示
            wx.hideLoading()
          }, 800)
        }
      }
    })
  })
}

const requestHandle = (msg, isPrePage) => {
  // 提示信息弹框
  if (msg) {
    wx.showToast({
      title: msg,
      icon: "none",
      mask: true,
      complete: () => {
        // 返回上一页
        if (isPrePage) {
          setTimeout(() => {
            wx.navigateBack({
              delta: 1
            })
          }, 1800)
        }
      }
    })
  }
}

const requestByGet = (url, param, configuration) => {
  return http("GET", url, param, configuration)
}

const requestByPost = (url, param, configuration) => {
  return http("POST", url, param, configuration)
}

module.exports = {
  formatTime: formatTime,
  chooseAddress: chooseAddress,
  login: login,
  getUserInfo: getUserInfo,
  requestByGet: requestByGet,
  requestByPost: requestByPost,
  guid: guid,
  arraySubtracting: arraySubtracting
}